JUC-Callable&ThreadPool

最新推荐文章于 2022-08-30 23:09:07 发布
最新推荐文章于 2022-08-30 23:09:07 发布
阅读量229 收藏
点赞数
分类专栏： 线程 文章标签： 线程池 Callable Executors
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tebtebtebteb/article/details/82966691
版权
本文详细介绍了Java中线程池的使用方法，包括固定大小线程池、缓存线程池、单个线程的线程池及可定时执行任务的线程池。同时，深入探讨了Callable接口与FutureTask的运用，展示如何让线程执行任务并获取返回结果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

引入：

创建执行线程的方式有四种：

1.继承Thread类

2.实现Runnable接口

3.实现Callable接口

4.线程池

前两种用的最多，今天就来演示一下后两种方法创建线程，即实现Callable接口和使用线程池。

1、实现Callable接口：

Callable是JUC中的一个接口，相较于实现Runnable接口的方式，其方法可以有返回值，并且可以抛出异常。另外，使用Callable接口需要FutureTask实现类的支持，用于接收运算结果。FutureTask是Future接口的实现类。

实际操作：

package com.tongtong.app7;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestCallable {

    public static void main(String[] args) {

        ThreadDemo td = new ThreadDemo();

        //1.使用Callable，需要FutureTask实现类的支持，用于接收运算结果
        FutureTask<Integer> result = new FutureTask<>(td);

        new Thread(result).start();

        //2.接收线程运算后的结果
        try {
            Integer sum = result.get();
            System.out.println(sum);
            System.out.println("---------------------");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class ThreadDemo implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {

        int sum = 0;

        for(int i = 0;i <= 100000; i++){
            sum += i;
        }

        return sum;
    }
}

 

2、线程池

线程池：提供一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。

二、线程池的体系结构：

java.util.concurrent.Executor:负责线程的使用与调度的根接口
    |--ExecutorService 子接口:线程池的主要接口（重要）
       |--ThreadPoolExecutor 线程池的实现类
       |--ScheduledExecutorService:子接口：负责线程的调度
           |--ScheduledThreadPoolExecutor :继承ThreadPoolExecutor,实现ScheduledExecutorService

三、工具类 ： Executors

ExecutorService newFixedThreadPool() : 创建固定大小的线程池
ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量
ExecutorService newSingleThreadExecutor() : 创建单个线程池，线程池中只有一个线程
ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务

实际操作： 

1、创建固定大小的线程池（ExecutorService newFixedThreadPool()）

package com.tongtong.app8;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class TestThreadPool {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1、创建固定大小的线程池
        ExecutorService pool = Executors.newFixedThreadPool(5);

        List<Future<Integer>> list = new ArrayList<>();

        for(int i = 0;i < 10; i++){ //分配10个任务
            //接收返回值
            Future<Integer> future = pool.submit(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {

                    int sum = 0;

                    for(int i =0;i <= 100;i++){
                        sum += i;
                    }
                    return sum;
                }
            });

            list.add(future);
        }
        //关闭线程池
        pool.shutdown();

        for(Future<Integer> future : list){
            System.out.println(future.get());
        }

    }
}

 

2、创建缓存线程池（ExecutorService newCachedThreadPool()）

package com.tongtong.app8;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class TestThreadPool {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1、创建缓存的线程池
        ExecutorService pool = Executors.newCachedThreadPool(5);

        List<Future<Integer>> list = new ArrayList<>();

        for(int i = 0;i < 10; i++){ //分配10个任务
            //接收返回值
            Future<Integer> future = pool.submit(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {

                    int sum = 0;

                    for(int i =0;i <= 100;i++){
                        sum += i;
                    }
                    return sum;
                }
            });

            list.add(future);
        }
        //关闭线程池
        pool.shutdown();

        for(Future<Integer> future : list){
            System.out.println(future.get());
        }

    }
}

3、创建单个线程的线程池（ExecutorService newSingleThreadExecutor()）

package com.tongtong.app8;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class TestThreadPool {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1、创建线程池
        ExecutorService pool = Executors.newSingleThreadExecutor();

        List<Future<Integer>> list = new ArrayList<>();

        for(int i = 0;i < 10; i++){
            Future<Integer> future = pool.submit(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {

                    int sum = 0;

                    for(int i =0;i <= 100;i++){
                        sum += i;
                    }
                    return sum;
                }
            });

            list.add(future);
        }

        pool.shutdown();

        for(Future<Integer> future : list){
            System.out.println(future.get());
        }
    }
}

4、创建固定大小的线程池，可以延迟或定时的执行任务（ScheduledExecutorService newScheduledThreadPool()）

package com.tongtong.app8;

import java.util.Random;
import java.util.concurrent.*;

public class TestScheduledThreadPool {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
        for(int i = 0;i < 5; i++){
            Future<Integer> result = pool.schedule(new Callable<Integer>() {

                @Override
                public Integer call() throws Exception {
                    int num = new Random().nextInt(100);
                    System.out.println(Thread.currentThread().getName() + " : " + num);
                    return num;
                }
            },1, TimeUnit.SECONDS); //定时执行

            System.out.println(result.get());
        }

        pool.shutdown();
    }
}

 

 

 

 

juc-12-线程池2-线程池的使用
qq_20633779的博客
12-01 441
这是线程池第二篇文章，上一篇文章写了如何创建线程池，这篇文章用代码来演示通过 ThreadPoolExecutor 和 Executors的静态工厂方法创建线程池，以及这些线程池的基本使用，然后重点讲解 ThreadPoolExecutor 的实现接口 ExecutorService 中的常用API，如何通过这些API来管理线程池。 1、ThreadPoolExecutor 创建线程池 从上篇文章《juc-12-线程池2-线程池的使用》中，我们学习到 ThreadPoolExecutor 几个重载的构造
【JUC 二】Callable Runnable 同步辅助类 读写锁 阻塞队列 线程池
2401_84010836的博客
04-19 1031
由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档还有更多面试复习笔记分享如下《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。
JUC学习（四）--线程池的学习
行无所至，学无所尽。
07-18 316
ThreadPool线程池 线程池概述 线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。 线程池的优势 线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出
ThreadPool 之 Callable、Future 和 FutureTask
RojerAlone的博客
08-03 709
ThreadPool 之 Callable、Future 和 FutureTaskCallable、Future 和 FutureTask　　一般情况下，线程有两种创建方式，一种是继承 Thread 类，一种是实现 Runnable 接口。在线程运行执行的都是 run 方法，这是一个 void 方法，没有返回值。如果要获取线程执行的结果，就必须传入一个变量，在执行完之前将结果写入这个变量中。　　从
JUC-ThreadPool
CB_Beginner的博客
02-11 267
一、什么是线程池 线程池的优势： 线程池做的工作只要是控制运行的线程数量， 处理过程中将任务放入队列 ，然后在线程创建后启动这些任务， 如果线程数量超过了最大数量，超出数量的线程排队等候 ，等其他线程执行完毕，再从队列中取出任务来执行。 它的主要特点为： 线程复用;控制最大并发数;管理线程。 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。 第二：提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。 第三：提高线程的可管理性。线程是稀缺资源，如果无限
java多线程Callable接口+ThreadPoolExecutor
congcong7267的博客
12-18 882
最近开发过程中遇到了请求接口耗时较长且需多次请求，故使用多线程处理。 多线程采用的是实现Callable接口+线程池ThreadPoolExecutor，下面是部分处理过后的代码，避免忘记故记录下来。 import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; import java.util.concurrent.*; /** * @Author xxx * @dat
JUC-ThreadPool线程池
思变的博客
12-28 293
1.四种线程池 public class ThreadPool_ { public static void main(String[] args) { //singleTheadPoolTest(); //fixTheadPoolTest(); //cacheThreadPool(); scheduleThreadPool(); } //corePoolSize=1,maximumPoolSize=1 //k
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 996
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
JUC详细笔记
leedoc的博客
11-05 985
此笔记根据黑马JUC课程整理 1.JUC概述 1.1什么是juc 在 Java 中，线程部分是一个重点，本篇文章说的 JUC 也是关于线程的。JUC就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包，JDK 1.5 开始出现的。 1.2 线程和进程概念 1.进程和线程 进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其
JUC周阳视频笔记
weixin_42861874的博客
06-08 622
JUC周阳视频笔记 这是自己一点一点整理的笔记，有空了一直完善，希望对大家有帮助。 视频地址：https://www.bilibili.com/video/BV1vE411D7KE?p=38 JUC的内容可以从p38-p72开始观看 p47-p48 8锁的现象及解释 8锁的原理可以从问题入手 标准访问，请间先打印邮件还是短信? 邮件方法暂停4秒钟，清问先打印邮件还是短信? 新增一个普通方法hello()， 请问先打印邮件还是hello ? 两部手机，请间先打印邮件还是短信? 两个静态同步方法，同一
Callable+ThreadPoolExecutor实现多线程并发并获得返回值
tangyb828的博客
04-21 962
一、前言 经常会遇到一些性能问题，比如调用某个接口，可能要循环调用100次，并且需要拿到每一次调用的返回结果，通常我们都是放在for循环中一次次的串行调用，这种方式可想而知道有多慢，那怎么解决这个问题呢？ 二、多线程 为了解决以上问题，我使用的方式是多线程。多线程常规的有两种实现方式，即继承Tread类，实现Runnable接口，但是这两种实现方式，有一个共同的问题，就是没有返回值，对于我们来说，...
JUC之线程池详解
weixin_38568503的博客
03-07 968
使用：
22-08-30 西安JUC（03） Callable接口、BlockingQueue阻塞队列、ThreadPool线程池
m0_56799642的博客
08-30 411
使用Callable创建的子线程需要借助FutureTask对象来执行它的call方法 阻塞队列：添加元素 获取元素 移除元素的方法有4套
JUC并发编程（十一）-线程池ThreadPoolExecutor详解
二总的猫
02-26 584
11、线程池 线程池重点内容：三大方法、7大参数、拒绝策略、优化配置。 11.1. 线程池原理 池化技术 ​ 程序运行的本质：占用系统资源，CPU/磁盘网络进行使用！我们希望可以高效的使用！池化技术就是演进出来的。 ​ 简单的说，池化技术就是：提前准备一些资源、以供使用！ ​ 线程池、连接池、内存池、对象池…这些东西都是池化技术。 ​ 线程的创建和销毁，...
JAVA多线程进阶篇 11、JUC线程池之ThreadPoolExecutor
EndlessProcess的专栏
03-14 3555
为了更好的对线程进行管理，实现线程的统一分配，调优和监控，降低资源消耗，JUC设计了线程池。Executors实现了多个静态方法来创建各种线程池，在正式工作中，我们应当实现自定义的ThreadPoolExecutor 。
ThreadPool+CountDownLatch+Callable实现多线程编程
tony_java_2017的博客
05-07 866
问题背景： 在Java web项目中，Service层的实现类中需要一个方法连续调用多个别的APP的API，且请求结果之间互相不依赖。如果在项目中给每个方法内部都去新建指定数量的线程，则在高并发场景下由于线程创建的过多，会导致系统资源消耗过多，系统运行变慢或者宕机，所以需要使用线程池；每次api请求之后有返回结果，需要拿到返回结果，并感知可能发生的异常，因此要使用Callable接口实现...
Callable+ThreadPoolExecutor实现多线程并发并获得返回值（转）
weixin_30378311的博客
09-12 727
出处：https://blog.csdn.net/kity9420/article/details/80740466 前言 　　经常会遇到一些性能问题，比如调用某个接口，可能要循环调用100次，并且需要拿到每一次调用的返回结果，通常我们都是放在for循环中一次次的串行调用，这种方式可想而知道有多慢，那怎么解决这个问题呢？ 多线程 　　为了解决以上问题，我使用的方式是多线程...
使用ThreadPoolExecutor和Callable的总结
qq_36976949的博客
10-30 2092
最近一直在研究多线程，走了很多坑，总算把多线程的使用搞清楚了。 阿里的开发文档对多线程的创建强制使用ThreadPoolExecutor，相比Executors，前者更直观的展现多线程内部的运行机制，且也可以合理的运用资源。 下面把代码贴上，简单说下练习中遇到的问题。 public class ThreadControl extends HttpServlet{     private St...
java JUC-AQS
最新发布
02-19
### Java JUC AQS 并发编程 抽象队列同步器 使用教程 源码解析 #### 什么是AQS？ `AbstractQueuedSynchronizer`（简称AQS），作为Java并发包中的核心组件之一，提供了用于实现锁和其他同步器的基础框架。它不仅简化了锁和同步工具的创建过程，还提高了这些工具的工作效率[^2]。 #### 类图结构与工作原理 AQS的设计围绕着一个FIFO（先进先出）等待队列展开，该队列由多个节点组成，每个节点代表了一个正在等待获取资源的线程。每当有新的竞争者未能立即获得所需资源时，就会被构造成一个新的节点并加入到这个队列之中；而当现有持有者释放其持有的资源之后，则会从队头开始依次唤醒后续等待者去尝试占有资源[^5]。 #### 同步模式分类 为了适应不同场景下的需求，AQS支持两种主要类型的同步方式——独占式以及共享式： - **独占式**：一次只允许单个线程访问临界区，在这种情况下其他任何试图进入同一区域内的请求都将被迫挂起直到前序操作完成为止； - **共享式**：允许多个读取者同时存在而不互相干扰，只要不存在写入动作发生即可保持一致性和安全性[^3]。 #### 自定义同步器的关键接口 对于想要利用AQS来构建特定行为逻辑的新类型而言，开发者通常需要重载以下几个抽象方法以适配具体的应用环境： - `tryAcquire(int arg)` 和 `tryRelease(int arg)` - `tryAcquireShared(int arg)` 及 `tryReleaseShared(int arg)` - `isHeldExclusively()` 上述函数分别对应于独占/共享模式下对资源的操作控制流程，通过合理地覆盖它们可以轻松打造出满足业务特性要求的各种高级别同步原语[^1]。 ```java public class CustomSync extends AbstractQueuedSynchronizer { protected boolean tryAcquire(int acquires) { // 实现具体的独占式获取逻辑 return super.tryAcquire(acquires); } protected boolean tryRelease(int releases) { // 实现具体的独占式释放逻辑 return super.tryRelease(releases); } } ``` #### 队列管理机制详解 在实际运行过程中，AQS内部维护了一条双向链表形式的数据结构用来存储各个待处理的任务单元。每当新成员到来之时便会调用`enqueue()`方法将其追加至末端位置上形成完整的链条关系网状链接，并且借助CAS指令保证整个插入过程的安全可靠性质不受外界因素影响破坏[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值